Usenet 1993 July/InfoMagic USENET CD-ROM July 1993.ISO/sources/unix/volume11/jove.pch/part02

Internet Message Format | 1987-09-15 | 46.1 KB

Subject:  v11i046:  Jove upgrade kit, Part02/04
Newsgroups: comp.sources.unix
Sender: sources
Approved: [e-mail]

Submitted-by: Jonathan Payne  <[e-mail]>
Posting-number: Volume 11, Issue 46
Archive-name: jove.pch/Part02

#! /bin/sh
# This is a shell archive.  Remove anything before this line, then unpack
# it by saving it into a file and typing "sh file".  To overwrite existing
# files, type "sh file -c".  You can also feed this as standard input via
# unshar, or by typing "sh <file", e.g..  If this archive is complete, you
# will see the following message at the end:
#        "End of archive 2 (of 4)."
# Contents:  jove.pch.2
PATH=/bin:/usr/bin:/usr/ucb ; export PATH
if test -f 'jove.pch.2' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'jove.pch.2'\"
else
echo shar: Extracting \"'jove.pch.2'\" \(43705 characters\)
sed "s/^X//" >'jove.pch.2' <<'END_OF_FILE'
Xdiff -c ojove/fp.c jove/fp.c
X*** ojove/fp.c    Thu Jul 16 09:14:23 1987
X--- jove/fp.c    Fri Jun 12 10:30:44 1987
X***************
X*** 7,12 ****
X--- 7,13 ----
X
X  #include "jove.h"
X  #include "io.h"
X+ #include "ctype.h"
X  #include "termcap.h"
X  #include <sys/stat.h>
X  #include <sys/file.h>
X***************
X*** 14,22 ****
X
X  #define MAXFILES    20    /* good enough for my purposes */
X
X! static File    _openfiles[MAXFILES] = {0};
X
X! static File *
X  f_alloc(name, flags, fd, buffer, buf_size)
X  char    *name,
X      *buffer;
X--- 15,23 ----
X
X  #define MAXFILES    20    /* good enough for my purposes */
X
X! private File    _openfiles[MAXFILES] = {0};
X
X! private File *
X  f_alloc(name, flags, fd, buffer, buf_size)
X  char    *name,
X      *buffer;
X***************
X*** 106,111 ****
X--- 107,114 ----
X          return EOF;
X      fp->f_ptr = fp->f_base;
X      fp->f_cnt = read(fp->f_fd, fp->f_base, fp->f_bufsize);
X+     while (fp->f_cnt == -1 && errno == EINTR)
X+         fp->f_cnt = read(fp->f_fd, fp->f_base, fp->f_bufsize);
X      if (fp->f_cnt == -1) {
X          printf("[Read error %d]", errno);
X          fp->f_flags |= F_ERR;
X***************
X*** 147,152 ****
X--- 150,166 ----
X      _flush(EOF, fp);
X  }
X
X+ f_seek(fp, offset)
X+ register File    *fp;
X+ off_t    offset;
X+ {
X+     if (fp->f_flags & F_WRITE)
X+         flush(fp);
X+     fp->f_cnt = 0;        /* next read will filbuf(), next write
X+                    will flush() with no bad effects */
X+     lseek(fp->f_fd, (long) offset, L_SET);
X+ }
X+
X  _flush(c, fp)
X  register File    *fp;
X  {
X***************
X*** 182,188 ****
X          return EOF;
X      while (((c = getc(fp)) != EOF) && (c != '\n')) {
X          if (c == NULL)
X!             continue;    /* sorry we don't read nulls */
X          if (cp >= endp) {
X              add_mess(" [Line too long]");
X              rbell();
X--- 196,202 ----
X          return EOF;
X      while (((c = getc(fp)) != EOF) && (c != '\n')) {
X          if (c == NULL)
X!             break;        /* sorry we don't read nulls */
X          if (cp >= endp) {
X              add_mess(" [Line too long]");
X              rbell();
X***************
X*** 201,215 ****
X      return NIL;    /* this means okay */
X  }
X
X  /* Deals with output to the terminal, setting up the amount of characters
X     to be buffered depending on the output baud rate.  Why it's in a
X     separate file I don't know ... */
X
X! static char    one_buf;
X
X  int    BufSize = 1;
X
X! static File    _stdout = {1, 1, 1, F_WRITE, &one_buf, &one_buf};
X  File    *stdout = &_stdout;
X
X  /* put a string with padding */
X--- 215,264 ----
X      return NIL;    /* this means okay */
X  }
X
X+ /* skip to beginning of next line, i.e., next read returns first
X+    character of new line */
X+ f_toNL(fp)
X+ register File    *fp;
X+ {
X+     register int    c;
X+
X+     if (fp->f_flags & F_EOF)
X+         return;
X+     while (((c = getc(fp)) != EOF) && (c != '\n'))
X+         ;
X+     if (c == EOF)
X+         fp->f_flags |= F_EOF;
X+ }
X+
X+ f_readn(fp, addr, n)
X+ register File    *fp;
X+ register char    *addr;
X+ register int    n;
X+ {
X+     while (--n >= 0)
X+         *addr++ = getc(fp);
X+ }
X+
X+ f_getint(fp)
X+ File    *fp;
X+ {
X+     int    n = 0,
X+         c;
X+
X+     while (isdigit(c = getc(fp)))
X+         n = (n * 10) + c;
X+     return n;
X+ }
X+
X  /* Deals with output to the terminal, setting up the amount of characters
X     to be buffered depending on the output baud rate.  Why it's in a
X     separate file I don't know ... */
X
X! private char    one_buf;
X
X  int    BufSize = 1;
X
X! private File    _stdout = {1, 1, 1, F_WRITE, &one_buf, &one_buf};
X  File    *stdout = &_stdout;
X
X  /* put a string with padding */
Xdiff -c ojove/funcdefs.c jove/funcdefs.c
X*** ojove/funcdefs.c    Thu Jul 16 09:14:24 1987
X--- jove/funcdefs.c    Fri Jun 12 12:25:57 1987
X***************
X*** 6,11 ****
X--- 6,12 ----
X   ************************************************************************/
X
X  #include "jove.h"
X+ #include "ctype.h"
X
X  #ifndef TXT_TO_C
X  extern int
X***************
X*** 97,103 ****
X      ForChar(),
X      FSexpr(),
X      ForWord(),
X!     FourTime(),
X      GoLine(),
X      GrowWindow(),
X      IncFSearch(),
X--- 98,104 ----
X      ForChar(),
X      FSexpr(),
X      ForWord(),
X!     TimesFour(),
X      GoLine(),
X      GrowWindow(),
X      IncFSearch(),
X***************
X*** 167,172 ****
X--- 168,174 ----
X      SpelBuffer(),
X  #endif
X      SplitWind(),
X+     GotoWind(),
X      Remember(),
X      Forget(),
X      StrLength(),
X***************
X*** 354,363 ****
X--- 356,367 ----
X      FUNCTION, "forward-sentence", WIRED_CMD(Eos),
X      FUNCTION, "forward-word", WIRED_CMD(ForWord),
X      DefMajor(FUNDAMENTAL), "fundamental-mode", 0,
X+     FUNCTION, "gather-numeric-argument", WIRED_CMD(TimesFour),
X  #ifdef LISP
X      FUNCTION, "grind-s-expr", WIRED_CMD(GSexpr),
X  #endif
X      FUNCTION, "goto-line", WIRED_CMD(GoLine),
X+     FUNCTION, "goto-window-with-buffer", WIRED_CMD(GotoWind),
X      FUNCTION, "grow-window", WIRED_CMD(GrowWindow),
X      FUNCTION, "handle-tab", WIRED_CMD(Tab),
X      FUNCTION, "i-search-forward", WIRED_CMD(IncFSearch),
X***************
X*** 432,438 ****
X      FUNCTION, "pushd", WIRED_CMD(Pushd),
X      FUNCTION, "pwd", WIRED_CMD(prCWD),
X  #endif
X-     FUNCTION, "quadruple-numeric-argument", WIRED_CMD(FourTime),
X      FUNCTION, "query-replace-string", WIRED_CMD(QRepSearch),
X  #ifdef IPROCS
X      FUNCTION, "quit-process", WIRED_CMD(ProcQuit),
X--- 436,441 ----
X***************
X*** 520,530 ****
X          struct cmd    *which;
X          int    cmdlen,
X              found = 0;
X!         static struct cmd    *cmdhash[1 + 26];
X          static int    beenhere = NO;
X
X  /* special case for prefix commands--only upper case ones */
X! #define hash(c)    ((c == 'P') ? 0 : 1 + (c - 'a'))
X
X          /* initialize the hash table */
X          if (beenhere == NO) {
X--- 523,533 ----
X          struct cmd    *which;
X          int    cmdlen,
X              found = 0;
X!         static struct cmd    *cmdhash[26];
X          static int    beenhere = NO;
X
X  /* special case for prefix commands--only upper case ones */
X! #define hash(c)    (c - 'a')
X
X          /* initialize the hash table */
X          if (beenhere == NO) {
X***************
X*** 539,546 ****
X          }
X
X          /* gather the cmd name */
X!         while (((c = getch()) != EOF) && !index(" \t\r\n", c))
X              *cp++ = c;
X          if (c == EOF)
X              return 0;
X          *cp = '\0';
X--- 542,552 ----
X          }
X
X          /* gather the cmd name */
X!         while (((c = getch()) != EOF) && !index(" \t\r\n", c)) {
X!             if (isupper(c))
X!                 c = tolower(c);
X              *cp++ = c;
X+         }
X          if (c == EOF)
X              return 0;
X          *cp = '\0';
X***************
X*** 549,555 ****
X              return 0;
X
X          /* look it up (in the reduced search space) */
X!         for (cmd = cmdhash[hash(cmdbuf[0])]; cmd->Name[0] == cmdbuf[0]; cmd++) {
X              if (strncmp(cmd->Name, cmdbuf, cmdlen) == 0) {
X                  if (strcmp(cmd->Name, cmdbuf) == 0)
X                      return (data_obj *) cmd;
X--- 555,562 ----
X              return 0;
X
X          /* look it up (in the reduced search space) */
X!         if (islower(cmdbuf[0]))
X!             for (cmd = cmdhash[hash(cmdbuf[0])]; cmd != 0 && cmd->Name[0] == cmdbuf[0]; cmd++) {
X              if (strncmp(cmd->Name, cmdbuf, cmdlen) == 0) {
X                  if (strcmp(cmd->Name, cmdbuf) == 0)
X                      return (data_obj *) cmd;
X***************
X*** 556,562 ****
X                  found++;
X                  which = cmd;
X              }
X!         }
X          if (found > 1)
X              complain("[\"%s\" ambiguous]", cmdbuf);
X          else if (found == 0)
X--- 563,569 ----
X                  found++;
X                  which = cmd;
X              }
X!             }
X          if (found > 1)
X              complain("[\"%s\" ambiguous]", cmdbuf);
X          else if (found == 0)
X***************
X*** 565,581 ****
X              return (data_obj *) which;
X      } else {
X          static char    *strings[(sizeof commands) / sizeof (commands[0])];
X!         static int    beenhere = 0;
X          register int    com;
X
X!         if (beenhere == 0) {
X              register char    **strs = strings;
X!             register struct cmd    *c = commands;
X
X!             beenhere = 1;
X!             for (; c->Name; c++)
X                  *strs++ = c->Name;
X              *strs = 0;
X          }
X
X          if ((com = complete(strings, prompt, CASEIND)) < 0)
X--- 572,588 ----
X              return (data_obj *) which;
X      } else {
X          static char    *strings[(sizeof commands) / sizeof (commands[0])];
X!         static int    beenhere = NO;
X          register int    com;
X
X!         if (beenhere == NO) {
X              register char    **strs = strings;
X!             register struct cmd    *c;
X
X!             for (c = commands; c->Name != 0; c++)
X                  *strs++ = c->Name;
X              *strs = 0;
X+             beenhere = YES;
X          }
X
X          if ((com = complete(strings, prompt, CASEIND)) < 0)
Xdiff -c ojove/insert.c jove/insert.c
X*** ojove/insert.c    Thu Jul 16 09:14:25 1987
X--- jove/insert.c    Fri Jul 10 09:25:50 1987
X***************
X*** 96,108 ****
X          incrmt = (tabstop - (dotcol % tabstop));
X          if (dotcol + incrmt > goal)
X              break;
X!         Insert('\t');
X          dotcol += incrmt;
X      }
X      if (dotcol != goal)
X!         DoTimes(Insert(' '), (goal - dotcol));
X!     exp_p = NO;
X!     exp = 1;
X  }
X
X  SelfInsert()
X--- 96,106 ----
X          incrmt = (tabstop - (dotcol % tabstop));
X          if (dotcol + incrmt > goal)
X              break;
X!         insert_c('\t', 1);
X          dotcol += incrmt;
X      }
X      if (dotcol != goal)
X!         insert_c(' ', (goal - dotcol));
X  }
X
X  SelfInsert()
X***************
X*** 116,132 ****
X          register int    num,
X                  i;
X
X!         for (i = 0, num = exp, exp = 1; i < num; i++) {
X              int    pos = calc_pos(linebuf, curchar);
X
X              if (!eolp()) {
X                  if (linebuf[curchar] == '\t') {
X                      if ((pos + 1) == ((pos + tabstop) - (pos % tabstop)))
X!                         DelNChar();
X                  } else
X!                     DelNChar();
X              }
X!             Insert(LastKeyStruck);
X          }
X      } else
X          Insert(LastKeyStruck);
X--- 114,130 ----
X          register int    num,
X                  i;
X
X!         for (i = 0, num = arg_value(); i < num; i++) {
X              int    pos = calc_pos(linebuf, curchar);
X
X              if (!eolp()) {
X                  if (linebuf[curchar] == '\t') {
X                      if ((pos + 1) == ((pos + tabstop) - (pos % tabstop)))
X!                         del_char(FORWARD, 1);
X                  } else
X!                     del_char(FORWARD, 1);
X              }
X!             insert_c(LastKeyStruck, 1);
X          }
X      } else
X          Insert(LastKeyStruck);
X***************
X*** 139,151 ****
X
X  Insert(c)
X  {
X!     if (exp <= 0)
X          return;
X      modify();
X      makedirty(curline);
X!     ins_c(c, linebuf, curchar, exp, LBSIZE);
X!     IFixMarks(curline, curchar, curline, curchar + exp);
X!     curchar += exp;
X  }
X
X  /* Tab in to the right place for C mode */
X--- 137,155 ----
X
X  Insert(c)
X  {
X!     insert_c(c, arg_value());
X! }
X!
X! /* insert character C N times at point */
X! insert_c(c, n)
X! {
X!     if (n <= 0)
X          return;
X      modify();
X      makedirty(curline);
X!     ins_c(c, linebuf, curchar, n, LBSIZE);
X!     IFixMarks(curline, curchar, curline, curchar + n);
X!     curchar += n;
X  }
X
X  /* Tab in to the right place for C mode */
X***************
X*** 159,165 ****
X
X          ToIndent();
X          if (dotchar > curchar)
X!             m = MakeMark(curline, dotchar, FLOATER);
X          (void) lisp_indent();
X          if (m) {
X              ToMark(m);
X--- 163,169 ----
X
X          ToIndent();
X          if (dotchar > curchar)
X!             m = MakeMark(curline, dotchar, M_FLOATER);
X          (void) lisp_indent();
X          if (m) {
X              ToMark(m);
X***************
X*** 177,191 ****
X
X  QuotChar()
X  {
X!     int    c;
X!     extern int    alarmed;    /* If waitfor had to wait. */
X
X!     c = waitchar();
X!     if (alarmed)
X          message(key_strokes);
X!     if (c == CTL(J))
X!         LineInsert(exp);
X!     else if (c != CTL(@))
X          Insert(c);
X  }
X
X--- 181,195 ----
X
X  QuotChar()
X  {
X!     int    c,
X!         slow;
X
X!     c = waitchar(&slow);
X!     if (slow)
X          message(key_strokes);
X!     if (c == CTL('J'))
X!         LineInsert(arg_value());
X!     else if (c != CTL('@'))
X          Insert(c);
X  }
X
X***************
X*** 215,224 ****
X  #endif
X      SelfInsert();
X      if (MinorMode(ShowMatch) && !charp() && !in_macro()) {
X!         BackChar();    /* Back onto the ')' */
X          if ((int) bp == -1)
X              bp = m_paren(c, BACKWARD, NO, YES);
X!         ForChar();
X          if (bp != 0) {
X              nx = in_window(curwind, bp->p_line);
X              if (nx != -1) {        /* is visible */
X--- 219,228 ----
X  #endif
X      SelfInsert();
X      if (MinorMode(ShowMatch) && !charp() && !in_macro()) {
X!         b_char(1);    /* Back onto the ')' */
X          if ((int) bp == -1)
X              bp = m_paren(c, BACKWARD, NO, YES);
X!         f_char(1);
X          if (bp != 0) {
X              nx = in_window(curwind, bp->p_line);
X              if (nx != -1) {        /* is visible */
X***************
X*** 264,279 ****
X  #ifdef LISP
X      if (MajorMode(LISPMODE))
X          DelWtSpace();
X  #endif
X!     else if (blnkp(linebuf))
X          DelWtSpace();
X
X      /* If there is more than 2 blank lines in a row then don't make
X         a newline, just move down one. */
X!     if (exp == 1 && eolp() && TwoBlank())
X          SetLine(curline->l_next);
X      else
X!         LineInsert(exp);
X
X      if (indentp)
X  #ifdef LISP
X--- 268,284 ----
X  #ifdef LISP
X      if (MajorMode(LISPMODE))
X          DelWtSpace();
X+     else
X  #endif
X!         if (blnkp(linebuf))
X          DelWtSpace();
X
X      /* If there is more than 2 blank lines in a row then don't make
X         a newline, just move down one. */
X!     if (arg_value() == 1 && eolp() && TwoBlank())
X          SetLine(curline->l_next);
X      else
X!         LineInsert(arg_value());
X
X      if (indentp)
X  #ifdef LISP
X***************
X*** 292,298 ****
X      int    llen;
X
X      if (*str == 0)
X!         return;    /* ain't nothing to insert! */
X      DOTsave(&save);
X      llen = strlen(linebuf);
X      while (c = *str++) {
X--- 297,303 ----
X      int    llen;
X
X      if (*str == 0)
X!         return;        /* ain't nothing to insert! */
X      DOTsave(&save);
X      llen = strlen(linebuf);
X      while (c = *str++) {
X***************
X*** 314,328 ****
X      makedirty(curline);
X  }
X
X! OpenLine()
X  {
X      Bufpos    dot;
X
X      DOTsave(&dot);
X!     LineInsert(exp);    /* Open the lines... */
X      SetDot(&dot);
X  }
X
X  /* Take the region FLINE/FCHAR to TLINE/TCHAR and insert it at
X     ATLINE/ATCHAR in WHATBUF. */
X
X--- 319,338 ----
X      makedirty(curline);
X  }
X
X! open_lines(n)
X  {
X      Bufpos    dot;
X
X      DOTsave(&dot);
X!     LineInsert(n);    /* Open the lines... */
X      SetDot(&dot);
X  }
X
X+ OpenLine()
X+ {
X+     open_lines(arg_value());
X+ }
X+
X  /* Take the region FLINE/FCHAR to TLINE/TCHAR and insert it at
X     ATLINE/ATCHAR in WHATBUF. */
X
X***************
X*** 392,398 ****
X
X      /* Now must find a recently killed region. */
X
X!     if (exp < 0)
X          dir = 1;
X
X      killptr += dir;
X--- 402,408 ----
X
X      /* Now must find a recently killed region. */
X
X!     if (arg_value() < 0)
X          dir = 1;
X
X      killptr += dir;
X***************
X*** 468,474 ****
X      }
X  }
X
X! static
X  newchunk()
X  {
X      register Line    *newline;
X--- 478,484 ----
X      }
X  }
X
X! private
X  newchunk()
X  {
X      register Line    *newline;
X***************
X*** 520,526 ****
X  /* Remove the free lines, in chunk c, from the free list because they are
X     no longer free. */
X
X! static
X  remfreelines(c)
X  register struct chunk    *c;
X  {
X--- 530,536 ----
X  /* Remove the free lines, in chunk c, from the free list because they are
X     no longer free. */
X
X! private
X  remfreelines(c)
X  register struct chunk    *c;
X  {
X***************
X*** 584,595 ****
X      DOTsave(&dot);
X      FSexpr();
X      DOTsave(&end);
X-     exp = 1;
X      SetDot(&dot);
X      for (;;) {
X          if (curline == end.p_line)
X              break;
X!         line_move(FORWARD, NO);
X          if (!blnkp(linebuf))
X              (void) lisp_indent();
X      }
X--- 594,604 ----
X      DOTsave(&dot);
X      FSexpr();
X      DOTsave(&end);
X      SetDot(&dot);
X      for (;;) {
X          if (curline == end.p_line)
X              break;
X!         line_move(FORWARD, 1, NO);
X          if (!blnkp(linebuf))
X              (void) lisp_indent();
X      }
X***************
X*** 656,662 ****
X
X      DOTsave(&savedot);
X      SetDot(bp);
X!     DoTimes(ForChar(), 1);
X      if (linebuf[curchar] != '(') {
X          register Word    *wp;
X
X--- 665,671 ----
X
X      DOTsave(&savedot);
X      SetDot(bp);
X!     f_char(1);
X      if (linebuf[curchar] != '(') {
X          register Word    *wp;
X
X***************
X*** 669,675 ****
X              int    c_char = curchar;
X
X              WITH_TABLE(curbuf->b_major)
X!                 ForWord();
X              END_TABLE();
X              if (LookingAt("[ \t]*;\\|[ \t]*$", linebuf, curchar))
X                  curchar = c_char;
X--- 678,684 ----
X              int    c_char = curchar;
X
X              WITH_TABLE(curbuf->b_major)
X!                 f_word(1);
X              END_TABLE();
X              if (LookingAt("[ \t]*;\\|[ \t]*$", linebuf, curchar))
X                  curchar = c_char;
Xdiff -c ojove/io.c jove/io.c
X*** ojove/io.c    Thu Jul 16 09:14:28 1987
X--- jove/io.c    Fri Jun 19 16:00:59 1987
X***************
X*** 107,115 ****
X      }
X      DOTsave(&save);
X      dofread(fp);
X!     SetDot(&save);
X!     if (is_insert && io_chars > 0)
X          modify();
X      getDOT();
X      close_file(fp);
X  }
X--- 107,117 ----
X      }
X      DOTsave(&save);
X      dofread(fp);
X!     if (is_insert && io_chars > 0) {
X          modify();
X+         set_mark();
X+     }
X+     SetDot(&save);
X      getDOT();
X      close_file(fp);
X  }
X***************
X*** 121,127 ****
X      int    xeof = 0;
X      Line    *savel = curline;
X      int    savec = curchar;
X!     disk_line    f_getputl() ;
X
X      strcpy(end, linebuf + curchar);
X      xeof = f_gets(fp, linebuf + curchar, LBSIZE - curchar);
X--- 123,129 ----
X      int    xeof = 0;
X      Line    *savel = curline;
X      int    savec = curchar;
X!     extern disk_line    f_getputl();
X
X      strcpy(end, linebuf + curchar);
X      xeof = f_gets(fp, linebuf + curchar, LBSIZE - curchar);
X***************
X*** 157,169 ****
X  #ifndef CHDIR
X
X  char *
X! pr_name(fname)
X  char    *fname;
X  {
X      if (fname == 0)
X          return 0;
X
X!     if (strncmp(fname, HomeDir, HomeLen) == 0) {
X          static char    name_buf[100];
X
X          sprintf(name_buf, "~%s", fname + HomeLen);
X--- 159,171 ----
X  #ifndef CHDIR
X
X  char *
X! pr_name(fname, okay_home)
X  char    *fname;
X  {
X      if (fname == 0)
X          return 0;
X
X!     if (okay_home == YES && strncmp(fname, HomeDir, HomeLen) == 0) {
X          static char    name_buf[100];
X
X          sprintf(name_buf, "~%s", fname + HomeLen);
X***************
X*** 188,194 ****
X  }
X
X  char *
X! pr_name(fname)
X  char    *fname;
X  {
X      int    n;
X--- 190,196 ----
X  }
X
X  char *
X! pr_name(fname, okay_home)
X  char    *fname;
X  {
X      int    n;
X***************
X*** 201,207 ****
X          (fname[n] == '/'))
X          return fname + n + 1;
X
X!     if (strcmp(HomeDir, "/") != 0 && strncmp(fname, HomeDir, HomeLen) == 0) {
X          static char    name_buf[100];
X
X          sprintf(name_buf, "~%s", fname + HomeLen);
X--- 203,209 ----
X          (fname[n] == '/'))
X          return fname + n + 1;
X
X!     if (okay_home == YES && strcmp(HomeDir, "/") != 0 && strncmp(fname, HomeDir, HomeLen) == 0) {
X          static char    name_buf[100];
X
X          sprintf(name_buf, "~%s", fname + HomeLen);
X***************
X*** 256,268 ****
X
X  getCWD()
X  {
X!     char    *cwd = getenv("CWD");
X  #ifdef JOB_CONTROL
X      extern char    *getwd();
X      char    pathname[FILESIZE];
X  #endif
X
X      if (cwd == 0)
X  #ifdef JOB_CONTROL
X          cwd = getwd(pathname);
X  #else
X--- 258,273 ----
X
X  getCWD()
X  {
X!     char    *cwd;
X  #ifdef JOB_CONTROL
X      extern char    *getwd();
X      char    pathname[FILESIZE];
X  #endif
X
X+     cwd = getenv("CWD");
X      if (cwd == 0)
X+         cwd = getenv("PWD");
X+     if (cwd == 0)
X  #ifdef JOB_CONTROL
X          cwd = getwd(pathname);
X  #else
X***************
X*** 278,284 ****
X
X      s_mess(": %f ");
X      for (i = DirSP; i >= 0; i--)
X!         add_mess("%s ", pr_name(DirStack[i]));
X  }
X
X  prCWD()
X--- 283,289 ----
X
X      s_mess(": %f ");
X      for (i = DirSP; i >= 0; i--)
X!         add_mess("%s ", pr_name(DirStack[i], YES));
X  }
X
X  prCWD()
X***************
X*** 339,344 ****
X--- 344,350 ----
X      return offset;
X  }
X
X+ private
X  dfollow(file, into)
X  char    *file,
X      *into;
X***************
X*** 377,382 ****
X--- 383,389 ----
X
X  #endif CHDIR
X
X+ private
X  get_hdir(user, buf)
X  register char    *user,
X          *buf;
X***************
X*** 453,464 ****
X
X  WrtReg()
X  {
X!     DoWriteReg(0);
X  }
X
X  AppReg()
X  {
X!     DoWriteReg(1);
X  }
X
X  int    CreatMode = DFLT_MODE;
X--- 460,471 ----
X
X  WrtReg()
X  {
X!     DoWriteReg(NO);
X  }
X
X  AppReg()
X  {
X!     DoWriteReg(YES);
X  }
X
X  int    CreatMode = DFLT_MODE;
X***************
X*** 474,480 ****
X      fname = ask_file((char *) 0, (char *) 0, fnamebuf);
X
X  #ifdef BACKUPFILES
X!     if (!app) {
X          filemunge(fname);
X
X          if (BkupOnWrite)
X--- 481,487 ----
X      fname = ask_file((char *) 0, (char *) 0, fnamebuf);
X
X  #ifdef BACKUPFILES
X!     if (app == NO) {
X          filemunge(fname);
X
X          if (BkupOnWrite)
X***************
X*** 511,522 ****
X
X      chk_mtime(curbuf, fname, "write");
X      filemunge(fname);
X!     curbuf->b_type = B_FILE;      /* In case it wasn't before. */
X      setfname(curbuf, fname);
X      file_write(fname, 0);
X      unmodify();
X  }
X
X  File *
X  open_file(fname, buf, how, ifbad, loudness)
X  register char    *fname;
X--- 518,545 ----
X
X      chk_mtime(curbuf, fname, "write");
X      filemunge(fname);
X!     curbuf->b_type = B_FILE;      /* in case it wasn't before */
X      setfname(curbuf, fname);
X      file_write(fname, 0);
X      unmodify();
X  }
X
X+ /* Open file FNAME supplying the buffer IO routine with buffer BUF.
X+    HOW is F_READ, F_WRITE or F_APPEND.  IFBAD == COMPLAIN means that
X+    if we fail at opening the file, call complain.  LOUDNESS says
X+    whether or not to print the "reading ..." message on the message
X+    line.
X+
X+    NOTE:  This opens the pr_name(fname, NO) of fname.  That is, FNAME
X+       is usually an entire pathname, which can be slow when the
X+       pathname is long and there are lots of symbolic links along
X+       the way (which has become very common in my experience).  So,
X+       this speeds up opens file names in the local directory.  It
X+       will not speed up things like "../scm/foo.scm" simple because
X+       by the time we get here that's already been expanded to an
X+       absolute pathname.  But this is a start.
X+    */
X+
X  File *
X  open_file(fname, buf, how, ifbad, loudness)
X  register char    *fname;
X***************
X*** 529,535 ****
X      io_lines = 0;
X      tellall = loudness;
X
X!     fp = f_open(fname, how, buf, LBSIZE);
X      if (fp == NIL) {
X                  message(IOerr((how == F_READ) ? "open" : "create", fname));
X          if (ifbad == COMPLAIN)
X--- 552,558 ----
X      io_lines = 0;
X      tellall = loudness;
X
X!     fp = f_open(pr_name(fname, NO), how, buf, LBSIZE);
X      if (fp == NIL) {
X                  message(IOerr((how == F_READ) ? "open" : "create", fname));
X          if (ifbad == COMPLAIN)
X***************
X*** 537,547 ****
X      } else {
X          int    readonly = FALSE;
X
X!         if (access(fname, W_OK) == -1 && errno != ENOENT)
X              readonly = TRUE;
X
X          if (loudness != QUIET)
X!             f_mess("\"%s\"%s", pr_name(fname),
X                     readonly ? " [Read only]" : NullStr);
X      }
X      return fp;
X--- 560,570 ----
X      } else {
X          int    readonly = FALSE;
X
X!         if (access(pr_name(fname, NO), W_OK) == -1 && errno != ENOENT)
X              readonly = TRUE;
X
X          if (loudness != QUIET)
X!             f_mess("\"%s\"%s", pr_name(fname, YES),
X                     readonly ? " [Read only]" : NullStr);
X      }
X      return fp;
X***************
X*** 552,559 ****
X     doing.
X
X     I hate to use another stat(), but to use confirm we gotta
X!    do this before we open the file. */
X
X  chk_mtime(thisbuf, fname, how)
X  Buffer    *thisbuf;
X  char    *fname,
X--- 575,586 ----
X     doing.
X
X     I hate to use another stat(), but to use confirm we gotta
X!    do this before we open the file.
X
X+    NOTE: This stats FNAME after converting it to a path-relative
X+      name.  I can't see why this would cause a problem ...
X+    */
X+
X  chk_mtime(thisbuf, fname, how)
X  Buffer    *thisbuf;
X  char    *fname,
X***************
X*** 566,577 ****
X      if ((thisbuf->b_mtime != 0) &&        /* if we care ... */
X          (b = file_exists(fname)) &&        /* we already have this file */
X          (b == thisbuf) &&            /* and it's the current buffer */
X!         (stat(fname, &stbuf) != -1) &&    /* and we can stat it */
X          (stbuf.st_mtime != b->b_mtime)) {    /* and there's trouble. */
X              rbell();
X          redisplay();    /* Ring that bell! */
X              TOstart("Warning", TRUE);
X!             Typeout("\"%s\" now saved on disk is not what you last", pr_name(fname));
X          Typeout("visited or saved.  Probably someone else is editing");
X          Typeout("your file at the same time.");
X              if (how) {
X--- 593,604 ----
X      if ((thisbuf->b_mtime != 0) &&        /* if we care ... */
X          (b = file_exists(fname)) &&        /* we already have this file */
X          (b == thisbuf) &&            /* and it's the current buffer */
X!         (stat(pr_name(fname, NO), &stbuf) != -1) &&    /* and we can stat it */
X          (stbuf.st_mtime != b->b_mtime)) {    /* and there's trouble. */
X              rbell();
X          redisplay();    /* Ring that bell! */
X              TOstart("Warning", TRUE);
X!             Typeout("\"%s\" now saved on disk is not what you last", pr_name(fname, YES));
X          Typeout("visited or saved.  Probably someone else is editing");
X          Typeout("your file at the same time.");
X              if (how) {
X***************
X*** 626,632 ****
X          for (;;) {
X              rbell();
X              y_or_n = ask(NullStr, "Shall I make your changes to \"%s\" permanent? ", curbuf->b_name);
X!             c = Upper(*y_or_n);
X              if (c == 'Y' || c == 'N')
X                  break;
X          }
X--- 653,659 ----
X          for (;;) {
X              rbell();
X              y_or_n = ask(NullStr, "Shall I make your changes to \"%s\" permanent? ", curbuf->b_name);
X!             c = CharUpcase(*y_or_n);
X              if (c == 'Y' || c == 'N')
X                  break;
X          }
X***************
X*** 658,664 ****
X
X  private int    nleft,    /* number of good characters left in current block */
X          tmpfd = -1;
X! private disk_line    DFree = 1;
X              /* pointer to end of tmp file */
X  private char    *tfname;
X
X--- 685,691 ----
X
X  private int    nleft,    /* number of good characters left in current block */
X          tmpfd = -1;
X! disk_line    DFree = 1;
X              /* pointer to end of tmp file */
X  private char    *tfname;
X
X***************
X*** 682,691 ****
X      (void) unlink(tfname);
X  }
X
X! /* Get a line at `tl' in the tmp file into `buf' which should be LBSIZE
X!    long. */
X
X! int    Jr_Len;        /* Length of Just Read Line. */
X  private char    *getblock();
X
X  getline(addr, buf)
X--- 709,718 ----
X      (void) unlink(tfname);
X  }
X
X! /* get a line at `tl' in the tmp file into `buf' which should be LBSIZE
X!    long */
X
X! int    Jr_Len;        /* length of Just Read Line */
X  private char    *getblock();
X
X  getline(addr, buf)
Xdiff -c ojove/iproc-pipes.c jove/iproc-pipes.c
X*** ojove/iproc-pipes.c    Thu Jul 16 09:14:30 1987
X--- jove/iproc-pipes.c    Thu Jun 25 10:02:30 1987
X***************
X*** 13,20 ****
X  #include <signal.h>
X  #include <sgtty.h>
X
X- typedef struct process    Process;
X-
X  #define DEAD    1    /* Dead but haven't informed user yet */
X  #define STOPPED    2    /* Job stopped */
X  #define RUNNING    3    /* Just running */
X--- 13,18 ----
X***************
X*** 25,30 ****
X--- 23,29 ----
X  #define KILLED    2
X
X  #define isdead(p)    (p == 0 || proc_state(p) == DEAD || p->p_toproc == -1)
X+ #define makedead(p)    (proc_state(p) = DEAD)
X
X  #define proc_buf(p)    (p->p_buffer->b_name)
X  #define proc_cmd(p)    (p->p_name)
X***************
X*** 36,42 ****
X      ProcOutput,
X      NumProcs = 0;
X
X! static char *
X  pstate(p)
X  Process    *p;
X  {
X--- 35,41 ----
X      ProcOutput,
X      NumProcs = 0;
X
X! char *
X  pstate(p)
X  Process    *p;
X  {
X***************
X*** 54,65 ****
X          if (p->p_howdied == EXITED) {
X              if (p->p_reason == 0)
X                  return "Done";
X!             return sprint("[Exit %d]", p->p_reason);
X          }
X!         return sprint("[Killed %d]", p->p_reason);
X
X      default:
X!         return "Unknown state.";
X      }
X  }
X
X--- 53,64 ----
X          if (p->p_howdied == EXITED) {
X              if (p->p_reason == 0)
X                  return "Done";
X!             return sprint("Exit %d", p->p_reason);
X          }
X!         return sprint("Killed %d", p->p_reason);
X
X      default:
X!         return "Unknown state";
X      }
X  }
X
X***************
X*** 98,104 ****
X              finish(1);
X          read_proc(header.pid, header.nbytes);
X      }
X-     redisplay();
X      here = 0;
X      sigrelse(SIGCHLD);
X  }
X--- 97,102 ----
X***************
X*** 126,132 ****
X      }
X
X      if (nbytes == EOF) {        /* Okay to clean up this process */
X!         p->p_eof = 1;
X          NumProcs--;    /* As far as getch() in main is concerned */
X          return;
X      }
X--- 124,130 ----
X      }
X
X      if (nbytes == EOF) {        /* Okay to clean up this process */
X!         proc_close(p);
X          NumProcs--;    /* As far as getch() in main is concerned */
X          return;
X      }
X***************
X*** 155,166 ****
X      proc_kill(curbuf->b_process, SIGQUIT);
X  }
X
X! static
X  proc_close(p)
X  Process    *p;
X  {
X      (void) close(p->p_toproc);
X!     p->p_toproc = -1;    /* Writes will fail. */
X  }
X
X  do_rtp(mp)
X--- 153,164 ----
X      proc_kill(curbuf->b_process, SIGQUIT);
X  }
X
X! private
X  proc_close(p)
X  Process    *p;
X  {
X      (void) close(p->p_toproc);
X!     p->p_toproc = -1;    /* writes will fail */
X  }
X
X  do_rtp(mp)
X***************
X*** 228,234 ****
X          (void) dup2(ProcOutput, 1);
X          (void) dup2(ProcOutput, 2);
X          pclose(toproc);
X!         execv(Portsrv, args);
X          printf("Execl failed.\n");
X          _exit(1);
X      }
X--- 226,232 ----
X          (void) dup2(ProcOutput, 1);
X          (void) dup2(ProcOutput, 2);
X          pclose(toproc);
X!         execv(Portsrv, argv);
X          printf("Execl failed.\n");
X          _exit(1);
X      }
X***************
X*** 260,270 ****
X      /* Pop_wind() after everything is set up; important!
X         Bindings won't work right unless newbuf->b_process is already
X         set up BEFORE NEWBUF is first SetBuf()'d. */
X!     newp->p_mark = MakeMark(curline, curchar, FLOATER);
X
X      newp->p_toproc = toproc[1];
X      newp->p_reason = 0;
X-     newp->p_eof = 0;
X      NumProcs++;
X      (void) close(toproc[0]);
X      sigrelse(SIGCHLD);
X--- 258,267 ----
X      /* Pop_wind() after everything is set up; important!
X         Bindings won't work right unless newbuf->b_process is already
X         set up BEFORE NEWBUF is first SetBuf()'d. */
X!     newp->p_mark = MakeMark(curline, curchar, M_FLOATER);
X
X      newp->p_toproc = toproc[1];
X      newp->p_reason = 0;
X      NumProcs++;
X      (void) close(toproc[0]);
X      sigrelse(SIGCHLD);
Xdiff -c ojove/iproc-ptys.c jove/iproc-ptys.c
X*** ojove/iproc-ptys.c    Thu Jul 16 09:14:31 1987
X--- jove/iproc-ptys.c    Thu Jun 25 10:01:44 1987
X***************
X*** 12,17 ****
X--- 12,18 ----
X  #endif
X  #include <signal.h>
X  #include <sgtty.h>
X+ #include <errno.h>
X
X  #define DEAD    1    /* Dead but haven't informed user yet */
X  #define STOPPED    2    /* Job stopped */
X***************
X*** 23,28 ****
X--- 24,30 ----
X  #define KILLED    2
X
X  #define isdead(p)    (p == 0 || proc_state(p) == DEAD || p->p_fd == -1)
X+ #define makedead(p)    (proc_state(p) = DEAD)
X
X  #define proc_buf(p)    (p->p_buffer->b_name)
X  #define proc_cmd(p)    (p->p_name)
X***************
X*** 45,51 ****
X      extern struct ltchars ls1;
X  #endif
X
X! static char *
X  pstate(p)
X  Process    *p;
X  {
X--- 47,53 ----
X      extern struct ltchars ls1;
X  #endif
X
X! char *
X  pstate(p)
X  Process    *p;
X  {
X***************
X*** 60,71 ****
X          if (p->p_howdied == EXITED) {
X              if (p->p_reason == 0)
X                  return "Done";
X!             return sprint("exit(%d)", p->p_reason);
X          }
X!         return sprint("Killed(%d)", p->p_reason);
X
X      default:
X!         return "Unknown state.";
X      }
X  }
X
X--- 62,73 ----
X          if (p->p_howdied == EXITED) {
X              if (p->p_reason == 0)
X                  return "Done";
X!             return sprint("Exit %d", p->p_reason);
X          }
X!         return sprint("Killed %d", p->p_reason);
X
X      default:
X!         return "Unknown state";
X      }
X  }
X
X***************
X*** 98,111 ****
X      }
X
X      n = read(fd, ibuf, sizeof(ibuf) - 1);
X!     if (n == 0) {
X!         proc_close(p);
X!         NumProcs--;
X          return;
X      }
X      ibuf[n] = '\0';
X      proc_rec(p, ibuf);
X-     redisplay();
X  }
X
X  ProcKill()
X--- 100,123 ----
X      }
X
X      n = read(fd, ibuf, sizeof(ibuf) - 1);
X!     /* NOTE: This read somethings returns -1 when it's the first time
X!        we're reading the socket.  Errno was set to I/O error or something
X!        bizarre like that.  So, I'm choosing to ignore this.  I ignored
X!        it before, and what happened was random text was being inserted
X!        at the beginning of the buffer because the ibuf[n] = '\0' wasn't
X!         working right (ibuf[-1] = '\0'). */
X!     if (n == -1 && errno == EIO)
X          return;
X+     if (n <= 0) {
X+         if (n == 0) {
X+             makedead(p);
X+             return;
X+         }
X+         sprintf(ibuf, "\n[pty read error: %d]\n", errno);
X+         n = strlen(ibuf);
X      }
X      ibuf[n] = '\0';
X      proc_rec(p, ibuf);
X  }
X
X  ProcKill()
X***************
X*** 171,183 ****
X      (void) write(p->p_fd, &c, 1);
X  }
X
X! static
X  proc_close(p)
X  Process *p;
X  {
X      (void) close(p->p_fd);
X      global_fd &= ~(1 << p->p_fd);
X-     p->p_eof++;
X  }
X
X  do_rtp(mp)
X--- 183,194 ----
X      (void) write(p->p_fd, &c, 1);
X  }
X
X! private
X  proc_close(p)
X  Process *p;
X  {
X      (void) close(p->p_fd);
X      global_fd &= ~(1 << p->p_fd);
X  }
X
X  do_rtp(mp)
X***************
X*** 216,222 ****
X      va_list    ap;
X      char    *argv[32],
X          *cp;
X!     Window *owind    = curwind;
X      int    pid;
X      Process    *newp;
X      Buffer     *newbuf;
X--- 227,233 ----
X      va_list    ap;
X      char    *argv[32],
X          *cp;
X!     Window *owind = curwind;
X      int    pid;
X      Process    *newp;
X      Buffer     *newbuf;
X***************
X*** 348,354 ****
X
X      newp->p_fd = ttyfd;
X      newp->p_pid = pid;
X-     newp->p_eof = 0;
X
X      newbuf = do_select((Window *) 0, bufname);
X      newbuf->b_type = B_PROCESS;
X--- 359,364 ----
X***************
X*** 371,377 ****
X      newp->p_name = copystr(cmdbuf);
X      newp->p_state = RUNNING;
X      newp->p_reason = 0;
X!     newp->p_mark = MakeMark(curline, curchar, FLOATER);
X
X      newp->p_next = procs;
X      procs = newp;
X--- 381,387 ----
X      newp->p_name = copystr(cmdbuf);
X      newp->p_state = RUNNING;
X      newp->p_reason = 0;
X!     newp->p_mark = MakeMark(curline, curchar, M_FLOATER);
X
X      newp->p_next = procs;
X      procs = newp;
Xdiff -c ojove/iproc.c jove/iproc.c
X*** ojove/iproc.c    Thu Jul 16 09:14:32 1987
X--- jove/iproc.c    Wed Jun 24 12:52:13 1987
X***************
X*** 30,36 ****
X          if (!isdead(p)) {
X              if (killem == -1) {
X                  yorn = ask("y", "Should I kill your i-processes? ");
X!                 killem = (Upper(*yorn) == 'Y');
X              }
X              if (killem)
X                  proc_kill(p, SIGKILL);
X--- 30,36 ----
X          if (!isdead(p)) {
X              if (killem == -1) {
X                  yorn = ask("y", "Should I kill your i-processes? ");
X!                 killem = (CharUpcase(*yorn) == 'Y');
X              }
X              if (killem)
X                  proc_kill(p, SIGKILL);
X***************
X*** 50,56 ****
X  /* Process receive: receives the characters in buf, and appends them to
X     the buffer associated with p. */
X
X! static
X  proc_rec(p, buf)
X  register Process    *p;
X  char    *buf;
X--- 50,56 ----
X  /* Process receive: receives the characters in buf, and appends them to
X     the buffer associated with p. */
X
X! private
X  proc_rec(p, buf)
X  register Process    *p;
X  char    *buf;
X***************
X*** 68,88 ****
X      if (w != 0)
X          do_disp = (in_window(w, p->p_mark->m_line) != -1);
X      SetBuf(p->p_buffer);
X!     savepoint = MakeMark(curline, curchar, FLOATER);
X!     ToMark(p->p_mark);    /* Where output last stopped. */
X      if (savepoint->m_line == curline && savepoint->m_char == curchar)
X          sameplace++;
X
X      ins_str(buf, YES);
X      if (do_disp) {
X          w->w_line = curline;
X          w->w_char = curchar;
X          redisplay();
X      }
X-     MarkSet(p->p_mark, curline, curchar);
X-     if (!sameplace)
X-         ToMark(savepoint);    /* Back to where we were. */
X-     DelMark(savepoint);
X      SetBuf(saveb);
X  }
X
X--- 68,91 ----
X      if (w != 0)
X          do_disp = (in_window(w, p->p_mark->m_line) != -1);
X      SetBuf(p->p_buffer);
X!     savepoint = MakeMark(curline, curchar, M_FLOATER);
X!     ToMark(p->p_mark);        /* where output last stopped */
X      if (savepoint->m_line == curline && savepoint->m_char == curchar)
X          sameplace++;
X
X      ins_str(buf, YES);
X+     MarkSet(p->p_mark, curline, curchar);
X+     if (!sameplace)
X+         ToMark(savepoint);    /* back to where we were */
X+     DelMark(savepoint);
X+     /* redisplay now, instead of right after the ins_str, so that
X+        we don't get a bouncing effect if point is not the same as
X+        the process output position */
X      if (do_disp) {
X          w->w_line = curline;
X          w->w_char = curchar;
X          redisplay();
X      }
X      SetBuf(saveb);
X  }
X
X***************
X*** 95,105 ****
X          s_mess("Cannot kill %s!", proc_buf(p));
X  }
X
X! /* Deal with a process' death.  proc_rec turns on the FREEUP bit when it
X!    it gets the "EOF" from portsrv.  FREEUP'd processes get unlinked from
X!    the list, and the proc stucture and proc_buf(p) get free'd up, here. */
X
X- private
X  DealWDeath()
X  {
X      register Process    *p,
X--- 98,107 ----
X          s_mess("Cannot kill %s!", proc_buf(p));
X  }
X
X! /* Deal with a process' death.  Go through all processes and find
X!    the ones which have gotten EOF.  Delete them from the list and
X!    free up the memory, and insert a status string. */
X
X  DealWDeath()
X  {
X      register Process    *p,
X***************
X*** 108,114 ****
X
X      for (p = procs; p != 0; p = next) {
X          next = p->p_next;
X!         if (!p->p_eof) {
X              prev = p;
X              continue;
X          }
X--- 110,116 ----
X
X      for (p = procs; p != 0; p = next) {
X          next = p->p_next;
X!         if (p->p_state != DEAD) {
X              prev = p;
X              continue;
X          }
X***************
X*** 130,135 ****
X--- 132,138 ----
X      char    *fmt = "%-15s  %-15s  %-8s %s",
X          pidstr[10];
X
X+     DealWDeath();
X      if (procs == 0) {
X          message("[No subprocesses]");
X          return;
X***************
X*** 142,148 ****
X          sprintf(pidstr, "%d", p->p_pid);
X          Typeout(fmt, proc_buf(p), pstate(p), pidstr, p->p_name);
X      }
X-     DealWDeath();
X      TOstop();
X  }
X
X--- 145,150 ----
X***************
X*** 160,168 ****
X--- 162,193 ----
X  SendData(newlinep)
X  {
X      register Process    *p = curbuf->b_process;
X+     register char    *lp,
X+             *gp;    /* JF fix for better prompt handling */
X
X      if (isdead(p))
X          return;
X+     /* If the process mark was involved in a big deletion, because
X+        the user hit ^W or something, then let's do some magic with
X+        the process mark.  Problem is that if the user yanks back the
X+        text he deleted, the mark stays at the beginning of the region,
X+        and so the next time SendData() is called the entire region
X+        will be sent.  That's not good.  So, to deal with that we reset
X+        the mark to the last line, after skipping over the prompt, etc. */
X+     if (p->p_mark->m_flags & M_BIG_DELETE) {
X+         Bufpos    bp;
X+
X+         p->p_mark->m_flags &= ~M_BIG_DELETE;
X+
X+         DOTsave(&bp);
X+         ToLast();
X+         Bol();
X+         while (LookingAt(proc_prompt, linebuf, curchar))
X+             SetDot(dosearch(proc_prompt, 1, 1));
X+         MarkSet(p->p_mark, curline, curchar);
X+         SetDot(&bp);
X+     }
X+
X      if (lastp(curline)) {
X          Eol();
X          if (newlinep)
X***************
X*** 174,181 ****
X          while (LookingAt(proc_prompt, linebuf, curchar))
X              SetDot(dosearch(proc_prompt, 1, 1));
X          strcpy(genbuf, linebuf + curchar);
X!         ToLast();
X!         ins_str(genbuf, NO);
X      }
X  }
X
X--- 199,210 ----
X          while (LookingAt(proc_prompt, linebuf, curchar))
X              SetDot(dosearch(proc_prompt, 1, 1));
X          strcpy(genbuf, linebuf + curchar);
X!         Eof();
X!         gp = genbuf;
X!         lp = linebuf;
X!         while (*lp == *gp && *lp != '\0')
X!             lp++, gp++;
X!         ins_str(gp, NO);
X      }
X  }
X
X***************
X*** 222,233 ****
X  register int    pid;
X  union wait    w;
X  {
X-     char    str[128];
X      register Process    *child;
X
X      if ((child = proc_pid(pid)) == 0)
X          return;
X
X      if (WIFSTOPPED(w))
X          child->p_state = STOPPED;
X      else {
X--- 251,262 ----
X  register int    pid;
X  union wait    w;
X  {
X      register Process    *child;
X
X      if ((child = proc_pid(pid)) == 0)
X          return;
X
X+     UpdModLine = YES;        /* we're changing state ... */
X      if (WIFSTOPPED(w))
X          child->p_state = STOPPED;
X      else {
X***************
X*** 238,249 ****
X              child->p_reason = w.w_termsig;
X              child->p_howdied = KILLED;
X          }
X!         proc_close(child);
X      }
X-     sprintf(str, "[Process %s: %s]\n",
X-         proc_cmd(child),
X-         pstate(child));
X-     proc_rec(child, str);
X  }
X
X  /* Push/pod process bindings.  I openly acknowledge that this is a
X--- 267,286 ----
X              child->p_reason = w.w_termsig;
X              child->p_howdied = KILLED;
X          }
X!         {
X!             Buffer    *save = curbuf;
X!             char    mesg[128];
X!
X!             /* insert status message now */
X!             sprintf(mesg, "[Process %s: %s]\n",
X!                 proc_cmd(child),
X!                 pstate(child));
X!             SetBuf(child->p_buffer);
X!             ins_str(mesg, NO);
X!             SetBuf(save);
X!             redisplay();
X!         }
X      }
X  }
X
X  /* Push/pod process bindings.  I openly acknowledge that this is a
Xdiff -c ojove/jove.c jove/jove.c
X*** ojove/jove.c    Thu Jul 16 09:14:35 1987
X--- jove/jove.c    Fri Jul 10 09:25:50 1987
X***************
X*** 20,27 ****
X  #include <sgtty.h>
X  #else
X  #include <termio.h>
X- #endif SYSV
X  #include <fcntl.h>
X
X  #ifdef TIOCSLTC
X  struct ltchars    ls1,
X--- 20,27 ----
X  #include <sgtty.h>
X  #else
X  #include <termio.h>
X  #include <fcntl.h>
X+ #endif SYSV
X
X  #ifdef TIOCSLTC
X  struct ltchars    ls1,
X***************
X*** 62,71 ****
X      int    CoreDump = (code != 0 && code != SIGHUP),
X          DelTmps = 1;        /* Usually we delete them. */
X
X- #ifdef LSRHS
X-     if (CoreDump)
X-         setdump(1);
X- #endif
X      if (code == SIGINT) {
X          char    c;
X
X--- 62,67 ----
X***************
X*** 106,114 ****
X      if (CoreDump)
X          abort();
X  #ifdef PROFILING
X!     exit(exp_p);
X  #else
X!     _exit(exp_p);
X  #endif
X  }
X
X--- 102,110 ----
X      if (CoreDump)
X          abort();
X  #ifdef PROFILING
X!     exit(0);
X  #else
X!     _exit(0);
X  #endif
X  }
X
X***************
X*** 137,143 ****
X      }
X      if (fcntl(fd, F_SETFL, on ? blockf : nonblockf) == -1)
X      finish(SIGHUP);
X-     return;
X  }
X  #endif SYSV
X
X--- 133,138 ----
X***************
X*** 399,405 ****
X  }
X
X  int    OKXonXoff = 0,        /* ^S and ^Q initially DON'T work */
X!     IntChar = CTL(]);
X
X  ttsize()
X  {
X--- 394,400 ----
X  }
X
X  int    OKXonXoff = 0,        /* ^S and ^Q initially DON'T work */
X!     IntChar = CTL(']');
X
X  ttsize()
X  {
X***************
X*** 500,505 ****
X--- 495,502 ----
X      TABS = !((sg1.c_oflag & TAB3) == TAB3);
X      ospeed = sg1.c_cflag & CBAUD;
X
X+     if (OKXonXoff)
X+         sg2.c_iflag &= ~(IXON | IXOFF);
X      sg2.c_iflag &= ~(INLCR|ICRNL|IGNCR);
X      sg2.c_lflag &= ~(ISIG|ICANON|ECHO);
X      sg2.c_oflag &= ~(OCRNL|ONLCR);
X***************
X*** 584,591 ****
X
X      if (cp == 0) {
X          rbell();
X!         exp = 1;
X!         exp_p = errormsg = NO;
X          message(NullStr);
X      } else
X          ExecCmd(cp);
X--- 581,588 ----
X
X      if (cp == 0) {
X          rbell();
X!         clr_arg_value();
X!         errormsg = NO;
X          message(NullStr);
X      } else
X          ExecCmd(cp);
X***************
X*** 662,668 ****
X
X  dorecover()
X  {
X!     execl(Recover, "jove_recover", "-d", TmpFilePath, (char *)0);
X      printf("%s: execl failed!\n", Recover);
X      flusho();
X      _exit(-1);
X--- 659,665 ----
X
X  dorecover()
X  {
X!     execl(Recover, "jove_recover", "-d", TmpFilePath, (char *) 0);
X      printf("%s: execl failed!\n", Recover);
X      flusho();
X      _exit(-1);
X***************
X*** 721,727 ****
X              case 't':
X                  ++argv;
X                  --argc;
X-                 exp_p = YES;
X                  find_tag(argv[1], YES);
X                  break;
X
X--- 718,723 ----
X***************
X*** 812,818 ****
X      Mark    *m;
X
X      sprintf(bname, "%s", curbuf->b_name);
X!     m = MakeMark(curline, curchar, FLOATER);
X
X      RecDepth++;
X      UpdModLine++;
X--- 808,814 ----
X      Mark    *m;
X
X      sprintf(bname, "%s", curbuf->b_name);
X!     m = MakeMark(curline, curchar, M_FLOATER);
X
X      RecDepth++;
X      UpdModLine++;
X***************
X*** 820,826 ****
X      UpdModLine++;
X      RecDepth--;
X      SetBuf(do_select(curwind, bname));
X!     if (exp_p == NO)
X          ToMark(m);
X      DelMark(m);
X  }
X--- 816,822 ----
X      UpdModLine++;
X      RecDepth--;
X      SetBuf(do_select(curwind, bname));
X!     if (!is_an_arg())
X          ToMark(m);
X      DelMark(m);
X  }
X***************
X*** 846,858 ****
X          if (RecDepth == 0) {
X              if (ModMacs()) {
X                  rbell();
X!                 if (Upper(*ask("No",
X  "Some MACROS haven't been saved; leave anyway? ")) != 'Y')
X                      break;
X              }
X              if (ModBufs(0)) {
X                  rbell();
X!                 if (Upper(*ask("No",
X  "Some buffers haven't been saved; leave anyway? ")) != 'Y')
X                      break;
X              }
X--- 842,854 ----
X          if (RecDepth == 0) {
X              if (ModMacs()) {
X                  rbell();
X!                 if (CharUpcase(*ask("No",
X  "Some MACROS haven't been saved; leave anyway? ")) != 'Y')
X                      break;
X              }
X              if (ModBufs(0)) {
X                  rbell();
X!                 if (CharUpcase(*ask("No",
X  "Some buffers haven't been saved; leave anyway? ")) != 'Y')
X                      break;
X              }
X***************
X*** 880,887 ****
X
X      for (;;) {
X          if (this_cmd != ARG_CMD) {
X!             exp = 1;
X!             exp_p = NO;
X              last_cmd = this_cmd;
X              init_strokes();
X          }
X--- 876,882 ----
X
X      for (;;) {
X          if (this_cmd != ARG_CMD) {
X!             clr_arg_value();
X              last_cmd = this_cmd;
X              init_strokes();
X          }
X***************
X*** 1051,1061 ****
X      }
X      if (scanvec(argv, "-r"))
X          dorecover();
X
X-     (void) time(&time0);
X      ttinit();    /* initialize terminal (after ~/.joverc) */
X      settout(ttbuf);    /* not until we know baudrate */
X-     ResetTerm();
X
X      (void) signal(SIGHUP, finish);
X      (void) signal(SIGINT, finish);
X--- 1046,1056 ----
X      }
X      if (scanvec(argv, "-r"))
X          dorecover();
X+     if (scanvec(argv, "-rc"))
X+         FullRecover();
X
X      ttinit();    /* initialize terminal (after ~/.joverc) */
X      settout(ttbuf);    /* not until we know baudrate */
X
X      (void) signal(SIGHUP, finish);
X      (void) signal(SIGINT, finish);
X***************
X*** 1071,1078 ****
X
X      /* set things up to update the modeline every UpdFreq seconds */
X      (void) signal(SIGALRM, updmode);
X!     (void) alarm((unsigned) UpdFreq);
X
X      cl_scr(1);
X      flusho();
X      RedrawDisplay();    /* start the redisplay process. */
X--- 1066,1075 ----
X
X      /* set things up to update the modeline every UpdFreq seconds */
X      (void) signal(SIGALRM, updmode);
X!     (void) time(&time0);
X!     (void) alarm((unsigned) (60 - (time0 % 60)));
X
X+     ResetTerm();
X      cl_scr(1);
X      flusho();
X      RedrawDisplay();    /* start the redisplay process. */
END_OF_FILE
if test 43705 -ne `wc -c <'jove.pch.2'`; then
    echo shar: \"'jove.pch.2'\" unpacked with wrong size!
fi
# end of 'jove.pch.2'
fi
echo shar: End of archive 2 \(of 4\).
cp /dev/null ark2isdone
MISSING=""
for I in 1 2 3 4 ; do
    if test ! -f ark${I}isdone ; then
    MISSING="${MISSING} ${I}"
    fi
done
if test "${MISSING}" = "" ; then
    echo You have unpacked all 4 archives.
    rm -f ark[1-9]isdone
else
    echo You still need to unpack the following archives:
    echo "        " ${MISSING}
fi
##  End of shell archive.
exit 0